home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Grab Bag
/
Shareware Grab Bag.iso
/
095
/
151b_src.arc
/
QBARCV2.ASM
< prev
next >
Wrap
Assembly Source File
|
1987-02-27
|
29KB
|
907 lines
page 74,132
title ARCV - Verbose ARC directory listing
; Special version of ARCV to be called by QB program
; usage:
;
; CALL ARCV (Workname$,"filename[.ARC]", RETCD%) ' CPC151AC
;
; notes:
; This code originated from ARCV 1.15d - Verbose ARC directory display
; written by V.Buerg and was modified to run as a called routine under
; Microsoft QuickBasic.
;
; Change 9/14/86 to dis-allow wildcards
; Change 1/1/87 to recognize squash format
; Change 2/18/87 to support network usage - - - - Jon Martin ' CPC151A
print macro name ; display a field
mov dx,offset name
call prints
endm
printl macro text ; display a literal
local txt,nxt
mov dx,offset txt
call prints
jmp nxt
txt db cr,lf,text
db stopper
nxt equ $
endm
header struc ; archive header
mbrcode db 0 ; compression code
mbrname db 13 dup (0) ; file name
mbrsize dw 0,0 ; file size in archive
mbrdate dw 0 ; creation date
mbrtime dw 0 ; creation time
mbrcrc dw 0 ; cyclic redunancy check
mbrlen dw 0,0 ; true file size, bytes
header ends
cseg segment public para 'CODE'
assume cs:cseg,ds:cseg,es:cseg
public arcv
arcv proc far
push bp ; save BASIC reg
mov bp,sp ; get parameter list pointer
mov cs:stkptr,sp ; save stack ptr
mov cs:saveds,ds ; save QB seg reg
mov cs:savees,es ; save QB seg reg
mov cs:errlvl,0 ; init return code
jmp start ; do our thing
; return with error
error: mov ax,cs ; insure seg regs
mov ds,ax ; for proper exit
mov es,ax
mov sp,cs:stkptr
mov errlvl,1 ; set bad return code
jmp arcv2a ; produce totals anyway
; set DOS error level and exit
exit: mov sp,cs:stkptr ; restore entry stack value
mov bx,word ptr cs:outhdl ; close listing file
or bx,bx ; if it was opened
jz exiting
mov ah,3eh
int 21h
exiting:
push ds ; restore QB dta
mov dx,word ptr cs:savedta[2]
mov ds,word ptr cs:savedta
mov ah,1ah
int 21h
pop ds
mov ds,word ptr cs:saveds ; recover QB seg regs
mov es,word ptr cs:savees
mov al,cs:errlvl ; get return code
cbw
mov bp,sp ; parm ptr from entry
mov di,word ptr 6[bp] ; ptr to retcd variable
stosw
pop bp
ret 6 ; clear parms from stack ' CPC151A
subttl '--- constants, equates and work areas'
page
cr equ 13
lf equ 10
bel equ 7
tab equ 9
stopper equ 0 ; end of display line indicator
arcmark equ 26 ; special archive marker
arcver equ 9 ; highest compression code used
stkptr dw 0 ; stack pointer upon entry
errlvl db 0 ; dos error level returned
flags db 0 ; find-first return code
archdl dw 0 ; file handle
arctitl db cr,lf,'Archive: '
arcname db 76 dup (stopper)
fileptr dw 0 ; ptr to filename part of arcname
savedta dw 0,0 ; addr of QB dta
dta db 48 dup (0) ; data transfer area
saveds dw 0 ; QB seg reg
savees dw 0 ; QB seg reg
outhdl dw 1 ; handle for output listing
temp db 76 dup (stopper); and temporary file name ' CPC151A
subttl '--- i/o control variables'
page
inbufsz equ 512 ; size of input buffer
inadr dw offset inbuf ; offset to input buffer
inptr dw offset inbuf ; offset to current byte
insize dw inbufsz ; size of input buffer
inlen dw 0 ; bytes left in buffer
incurh dw 0 ; current file offset
incurl dw 0 ; low word
usage db cr,lf
db 'QBARCV2 - Verbose ARC directory display for QuickBasic' ; ' CPC151A
db cr,lf,lf,' Usage: call arcv (workname$,arcname[.ARC],result%' ; ' CPC151A
db cr,lf,stopper
; display lines for verbose
vhdr db cr,lf
db cr,lf,'Name Length Stowage SF Size now Date Time CRC '
db cr,lf,'============ ======== ======== ==== ======== ========= ====== ===='
db stopper
vline db cr,lf
vname db 14 dup (' ')
vlength db ' 0 ' ; length in archive
vstyle db ' ' ; compression method
vfactor db ' xx% ' ; compression factor
vsize db 10 dup (' ') ; actual file bytes
vdate db 'dd ' ; creation date
vmonth db 'mmm '
vyear db 'yy '
vtime db 'hh:mm ' ; creation time
vcrc db 'xxxx' ; crc in hex
db stopper
hundred dw 100 ; for computing percentages
totsf dw 0,0 ; average stowage factor
totlen dw 0,0 ; total of file lengths
totsize dw 0,0 ; total of file sizes
totmbrs dw 0 ; total number of files
; final totals line
vthdr db cr,lf,lf,'*Total ' ; ' CPC151A
vtmbrs db ' '
vtlen db 8 dup (' '),' '
db 10 dup (' ')
vtsf db ' % '
vtsize db 8 dup (' ')
db cr,lf ; for tom
db stopper
sign db ' '
styles db ' ----- ' ; 1 = old, no compression
db ' ----- ' ; 2 = new, no compression
db ' Packed ' ; 3 = dle for repeat chars
db 'Squeezed' ; 4 = huffman encoding
db 'crunched' ; 5 = lz, no dle
db 'crunched' ; 6 = lz with dle
db 'Crunched' ; 7 = lz with readjust
db 'Crunched' ; 8 = lz with readjust and dle
db 'Squashed' ; 9 = 13-bit lz with no dle
months db 'Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec '
subttl '--- mainline processing'
page
;
; determine if command line or menu driven mode
start:
push ds
mov ax,cs ; set local seg regs
mov ds,ax
mov es,ax
mov word ptr inlen,ax ; initialize file variables
mov word ptr incurh,ax
mov word ptr incurl,ax
push cx ; bug fix
push di ; 03-Feb-1987
cld ; Steven M. Georgiades
mov di,offset arcname
mov al,0 ; Clears arcname for each call
mov cx,76
rep stosb
pop di
pop cx
pop ds ; ' CPC151A
mov si,word ptr 10[bp] ; ptr to parameter vector ' CPC151A
lodsw ; get string length ' CPC151A
mov cx,ax ; ' CPC151A
mov si,word ptr [si] ; get string offset ' CPC151A
mov di,offset temp ; ' CPC151A
; copy first parameter ' CPC151A
parm1: lodsb ; copy filename ' CPC151A
stosb ; ' CPC151A
loop parm1 ; loop until done ' CPC151A
push ds ; ' CPC151A
mov ax,cs ; set local seg regs ' CPC151A
mov ds,ax ; ' CPC151A
mov dx,offset temp ; open temporary file for output
mov cx,0
mov ah,3ch
int 21h
mov outhdl,ax
pop ds
jnc parm2a ; ' CPC151A
mov cs:errlvl,1 ; return error code
jmp exit
parm2a: mov si,word ptr 8[bp] ; ptr to parameter vector
lodsw ; get string length
mov cx,ax
mov si,word ptr [si] ; get string offset
or cx,cx ; any operand?
jnz parm2b ; ' CPC151A
print usage
jmp exit
; copy second parameter ' CPC151A
parm2b: ; ' CPC151A
mov di,offset arcname
parm2c: lodsb ; copy filename ' CPC151A
stosb
loop parm2c ; ' CPC151A
; find filename part
parm2d: ; ' CPC151A
mov ax,cs ; need local seg regs
mov ds,ax
mov es,ax
mov si,offset arcname+75 ; end of filename stuff
std
mov cl,76 ; search for last path
parm2e: ; ' CPC151A
lodsb
cmp al,'/' ; funny path delimiter?
je parm2f ; ' CPC151A
cmp al,'\' ; normal path delimiter?
je parm2f ; ' CPC151A
cmp al,':' ; bumped into drive?
je parm2f ; ' CPC151A
loop parm2e ; ' CPC151A
dec si
parm2f: ; ' CPC151A
cld
add si,2 ; point to where filename goes
mov fileptr,si ; and save for later
; add default ARC extension if necessary
mov si,fileptr ; start of filespec
mov cx,13
parm10:
lodsb
cmp al,0 ; end of name?
je parm11
cmp al,'.' ; got extension?
je parm12
loop parm10
parm11:
mov di,si ; ptr to end of name
dec di
mov ax,'A.' ; default extension
stosw
mov ax,'CR'
stosw
mov ax,0FF00h ; append stoppers
stosw
parm12:
; find first matching file
getfirst:
push es
mov ah,2fh ; get current dta ptr
int 21h ; returned in es:bx
mov word ptr savedta,es
mov word ptr savedta[2],bx
pop es
mov dx,offset dta ; set local dta for murkers
mov ah,1ah
int 21h
; re-initialize
not_found:
sub ax,ax ; reset totals counters
mov totmbrs,ax
mov totsize,ax
mov totsize+2,ax
mov totlen,ax
mov totlen+2,ax
mov totsf,ax
mov inlen,ax
mov incurl,ax
mov incurh,ax
mov dx,offset inbuf
mov inptr,dx
call openarc ; see if archive exists
jnc arcv1
jmp exit
page
;
; process next archive header entry
arcv1: print arctitl
print vhdr
arcvnext:
call gethdr ; load next header
jnc arcv2
jmp exit ; all done
arcv2: cmp archdr.mbrcode,0 ; archive eof?
je arcv2a
jmp arcvgo
arcv2a:
mov ax,totmbrs ; total files
or ax,ax ; are there any?
jnz format_totals
jmp skip_totals
format_totals:
sub dx,dx
mov si,offset vtmbrs-4
call format
mov dx,totlen+2 ; total actual file size
mov ax,totlen
mov si,offset vtlen
call format
mov dx,totsize+2 ; total achive file size
mov ax,totsize
mov si,offset vtsize
call format
; reduce the total size/length to word values
mov bx,totlen ; get actual file size
mov ax,totlen+2
mov cx,totsize ; length of file in archive
mov dx,totsize+2
arcv2b: or ax,ax ; big number?
jz arcv2c ; nope, can use it
shr ax,1 ; yup, divide by two
rcr bx,1
shr dx,1
rcr cx,1
jmp short arcv2b
arcv2c: mov si,offset vtsf-5 ; format stowage factor
mov ax,bx
mov sign,' ' ; whata kludge
cmp ax,cx ; arc is bigger than orig?
jb arcv2c1
sub ax,cx ; amount saved
jmp short arcv2f
arcv2c1:
sub ax,cx
neg ax
mov sign,'-'
arcv2f:
mul hundred ; to percentage
add ax,50
adc dx,0 ; round up percent
or bx,bx ; empty file?
jnz arcv2d
mov ax,100
jmp short arcv2e
arcv2d: div bx
arcv2e: sub dx,dx
call format
mov al,sign
mov vtsf,al
print vthdr ; display totals
skip_totals:
call closarc
jmp exit ; ' CPC151A
page
;
; format single line for each member
arcvgo:
mov di,offset vname ; copy file name
mov si,offset archdr.mbrname
mov cx,13
arcv3:
lodsb
cmp al,0 ; end of name?
je arcv4
stosb
loop arcv3
jmp short arcv5
arcv4:
mov al,' ' ; pad with blanks
rep stosb
arcv5:
inc totmbrs
; reduce the size/length to word values
mov bx,archdr.mbrlen ; get actual file size
mov ax,archdr.mbrlen+2
mov cx,archdr.mbrsize ; length of file in archive
mov dx,archdr.mbrsize+2
arcv51: or ax,ax ; big number?
jz arcv52 ; nope, can use it
shr ax,1 ; yup, divide by two
rcr bx,1
shr dx,1
rcr cx,1
jmp short arcv51
arcv52: mov si,offset vfactor-5 ; format stowage factor
mov ax,bx ; low word of actual size
mov sign,' '
cmp ax,cx ; arc member is larger?
jb arcv520
sub ax,cx ; amount saved
jmp arcv56
arcv520:
sub ax,cx
neg ax
mov sign,'-'
arcv56:
mul hundred ; to percentage
add ax,50
adc dx,0 ; round up percent
or bx,bx ; empty file?
jnz arcv53
mov ax,100
jmp short arcv54
arcv53: div bx
arcv54: sub dx,dx
cmp ax,100 ; archive fouled?
jbe arcv55
sub ax,ax
arcv55:
call format
mov al,sign
mov vfactor,al
sub bx,bx ; determine style
mov bl,archdr.mbrcode
mov cl,3 ; eight bytes each entry
shl bx,cl
lea si,styles-8[bx] ; get ptr to style name
mov di,offset vstyle
mov cx,8
rep movsb
mov si,offset vsize ; format file size
mov dx,archdr.mbrsize+2
mov ax,archdr.mbrsize
add totsize,ax
adc totsize+2,dx
call format
mov si,offset vlength ; format file length
mov dx,archdr.mbrlen+2
mov ax,archdr.mbrlen
add totlen,ax
adc totlen+2,dx
call format
mov ax,archdr.mbrdate ; format file date
call getdate
mov ax,archdr.mbrtime ; format file time
call gettime
mov ax,archdr.mbrcrc ; format crc in hex
mov di,offset vcrc
call cvh
print vline ; display this file info
mov cx,word ptr archdr.mbrsize+2
mov dx,word ptr archdr.mbrsize
add dx,incurl ; add current file offset
adc cx,0
add cx,incurh
mov ax,4200h ; skip over file data
mov bx,archdl
int 21h
mov incurh,dx ; new position
mov incurl,ax
mov inlen,0 ; reset read buffer
jmp arcvnext
subttl ' - miscellaneous subroutines'
page
openarc proc near ; open new archive
push bx
mov byte ptr errlvl,0
mov dx,offset arcname
mov ax,3d00h ; for input
int 21h
jc openerr
mov archdl,ax ; save file handle
clc
pop bx
ret
openerr:
printl 'Unable to open archive: '
print arcname
jmp error
openarc endp
closarc proc near
push bx
mov bx,archdl ; previous handle
or bx,bx ; already open?
jz closed
mov ah,3eh ; yes, so close it
int 21h
closed: mov archdl,0
pop bx
ret
closarc endp
;
; print string like int 21h function 9
prints proc near ; dx has offset to string
push si ; ending in char x'ff'
push bx
push cx
mov si,dx
sub cx,cx
ps1: lodsb
cmp al,stopper ; ending hex ff?
je ps9
inc cx ; incr text length
jmp ps1
ps9: mov ah,40h ; write to file
mov bx,outhdl ; using std out or temp file
int 21h
pop cx ; recover registers
pop bx
pop si
ret
prints endp
page
;
; format the time
time record hour:5,min:6,sec:5 ;packed time
gettime proc near ;format the date
mov di,offset vtime
or ax,ax ;it is zero?
jz gottime
push ax ;save date
and ax,mask hour ;get hour part
mov cl,hour ;bits to shift
shr ax,cl
call cnvrt1
stosw
mov al,':'
stosb
gt3: pop ax ;get the time back
and ax,mask min ;get min part
mov cl,min ;bits to shift
call cnvrt
stosw
gottime:ret
gettime endp
cnvrt2 proc near ;convert to ascii
call cnvrt
cmp al,'0' ;suppress leading zero
jne cnvrtd
mov al,' '
ret
cnvrt: shr ax,cl
cnvrt1: aam ;make al into bcd
or ax,'00' ; and to ascii
xchg al,ah
cnvrtd: ret
cnvrt2 endp
page
;
; format the date
date record yr:7,mo:4,dy:5 ;packed date
getdate proc near ;format the date
or ax,ax ;is it zero?
jz gotdate
push ax ;save date
and ax,mask yr ;get year part
mov cl,yr ;bits to shift
call cnvrt
mov di,offset vyear
or al,'8' ;adjust for base year
stosw
pop bx ;get the date back
push bx ;save it
and bx,mask mo ;get month part
mov cl,mo ;bits to shift
shr bx,cl
add bx,bx ; form month table index
add bx,bx
lea si,word ptr months-4[bx]
mov cx,3
mov di,offset vmonth
rep movsb
pop ax ;get the date back
and ax,mask dy ;get day part
mov cl,dy ;bits to shift
call cnvrt
mov di,offset vdate
stosw
gotdate:ret
getdate endp
page
;
; ripped from sdir.asm. how does this work?
ddptr dw 0
format proc near ;formats a 32 bit integer in dx:ax
push bp ; to ds:si
push bx
push di
push si
mov ddptr,si ;addr of target field
mov di,dx ;routine uses di:si
mov si,ax
call printdd
pop si
pop di
pop bx
pop bp
ret
printdd:
xor ax,ax ;zero out the
mov bx,ax ; working
mov bp,ax ; registers.
mov cx,32 ;# bits of precision
j1: shl si,1
rcl di,1
xchg bp,ax
call j6
xchg bp,ax
xchg bx,ax
call j6
xchg bx,ax
adc al,0
loop j1
mov cx,1710h
mov ax,bx
call j2
mov ax,bp
j2: push ax
mov dl,ah
call j3
pop dx
j3: mov dh,dl
shr dl,1 ;move high
shr dl,1 ; nibble to
shr dl,1 ; the low
shr dl,1 ; position.
call j4
mov dl,dh
j4: and dl,0fh ;mask low nibble
jz j5 ;if not zero
mov cl,0
j5: dec ch
and cl,ch
or dl,'0' ;fold in ascii zero
sub dl,cl
mov bx,ddptr
mov [bx],dl ;ptr to next target field
inc ddptr
ret
j6: adc al,al
daa
xchg al,ah
adc al,al
daa
xchg al,ah
ret
format endp
page
cvh proc near ; convert 16-bit binary word in ax
push di ; to hex ASCII string at ds:di
push bx ; save registers
push cx
push dx
mov dx,ax ; save 16-bits
mov bl,dh ; third nibble
mov cl,4
shr bl,cl
mov al,hexchar[bx]
stosb
mov bl,dh ; last nibble
and bl,0fh
mov al,hexchar[bx]
stosb
mov bl,dl ; first nibble
mov cl,4
sub bh,bh
shr bl,cl ; isolate
mov al,hexchar[bx]
stosb
mov bl,dl ; second nibble
and bl,0fh ; isolate
mov al,hexchar[bx]
stosb
pop dx ; restore registers
pop cx
pop bx
pop di
ret ; return
hexchar db '0123456789ABCDEF'
cvh endp
subttl ' - i/o subroutines'
page
getc proc near ; return next byte in al
push si ; or cf=1 for eof
getc1:
dec inlen ; any left in buffer
jge getc2 ; yes, pick it up
call getblk
jnc getc1
pop si ; return cf=1 at eof
ret
getc2:
mov si,inptr ; offset to next byte
lodsb
mov inptr,si
add incurl,1 ; bump file offset
adc incurh,0
pop si
ret
getc endp
getblk proc near ; read next block
push bx
push cx
push dx
mov ah,3fh ; read from handle
mov bx,archdl ; arc file handle
mov cx,inbufsz ; input buffer size
mov dx,offset inbuf ; offset to input buffer
mov inptr,dx
int 21h
jc getblkr ; oops
or ax,ax ; anything read?
jnz getblka
stc ; no, set cf=1 for eof
jmp short getblkx ; and exit
getblka:
mov inlen,ax ; return count of bytes read
getblkx:
pop dx
pop cx
pop bx
ret
getblkr:
printl 'I/O error reading '
print arcname
jmp error ; gotta quit
getblk endp
subttl '--- load next archive header'
page
gethdr proc near
mov cx,132 ; gotta look for the damn thing
gethdr2:
call getc ; get next file byte
jc gethdrr1 ; premature eof
cmp al,arcmark ; start of header?
je gethdr3 ; yup, let's start cookin
loop gethdr2
gethdrr1:
printl 'Invalid archive format!'
jmp error
gethdr3:
call getc ; get version code
jc gethdrr1
mov archdr.mbrcode,al
cmp al,arcver ; reasonable code?
ja gethdrr1 ; nope, funny stuff
cmp al,0 ; archive eof?
je gethdr9 ; yup done
mov cx,13 ; get member name
mov di,offset archdr.mbrname
gethdr4:
call getc
jc gethdrr1
stosb
loop gethdr4
gethdr5:
mov cx,10 ; length remaining
cmp archdr.mbrcode,1 ; old format?
je gethdr6 ; yes, it's short
mov cl,14
gethdr6:
mov di,offset archdr.mbrsize
gethdr7:
call getc
jc gethdrr1
stosb
loop gethdr7
gethdr8:
cmp archdr.mbrcode,1 ; old format?
jne gethdr9 ; if so, it's short
mov si,offset mbrsize
mov di,offset mbrlen
mov cx,4
rep movsb
gethdr9:
clc
ret
gethdrr2:
printl 'Invalid archive header'
jmp error
gethdr endp
subttl '--- i/o data areas'
page
arcv endp
archdr db 64 dup (0) ; i/o area for a header
inbuf db inbufsz dup (0)
cseg ends
end arcv
